#include "arbreUCT.h"
#include "noeudUCT.h"
#include "../EPlateau.h"
#include "../all2.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>


//#define VALEUR_I 0.5

#define NBDESCENTES 1000
// CONSTRUCTEURS
/*
arbreUCT::arbreUCT() {
    nbrPassages = 0 ;
    nbrPiecesPosees  = 0 ;
    etage = 0;

    //plateau
    pInit = new EPlateau() ;
    //Coup co = {50,50, BLANC};
    noeudUCT * temp = NULL;
    firstNoeud = new noeudUCT(temp);
    firstNoeud->creerToutLesFils(pInit);
    nbNoeud = firstNoeud->getNbrFils();
    lastNoeud = firstNoeud ;
    //lastCoup = NULL ;
    srand ( time(NULL) );
    mode = 1;
    //couleur = NOIR;
    // la liste chainee pour nous aider a choisir un noeud
    fichierlogthread = NULL;
}
*/
arbreUCT::arbreUCT(EPlateau * plateau, vector<pthread_mutex_t> * tM,  vector<pthread_mutex_t> * Mut, vector<vector<vecteurRave> > * lC) {
    cout<<"construction classique d'un arbre : "<<endl;
    nbrPassages = 0 ;
    nbrPiecesPosees  = 0 ;
    etage = 0;
    //plateau
    pInit = plateau ;
    pActuel =   new EPlateau(plateau);
    tableMutex=tM;
    Mutex=Mut;
    listeChainee=lC;
    //  Coup co = {50,50, BLANC};
    noeudUCT * temp = NULL;
    cout<<"arbre en construction"<<endl;
    firstNoeud = new noeudUCT(temp);
    listeCustom = new vector<vector<vecteurRave> > ;
    cout<<"noeud construit!"<<endl;
    //  firstNoeud->creerToutLesFils(pInit);

    listeCustom->resize(lC->size());
    for (int i=0;i < (*lC).size(); i++) {
        (*listeCustom)[i].resize((*lC)[i].size());
    }
    pthread_mutex_lock(&(*Mutex)[0]);
    cout<<"initialisation le listeCustom"<<endl;
    //int pause;
    //cin>>pause;
    for (int i=0; i<lC->size(); i++) {
        for (int j =0;j<(*lC)[i].size(); j++) {
        	cout<<" i j :"<<i<<" "<<j<<endl;
            (*listeCustom)[i][j] = new vecteurRave((*lC)[i][j]);
        }
    }
    cout<<"tableau de vecteurs rave construits"<<endl;
    //cin>>pause;
    pthread_mutex_unlock(&(*Mutex)[0]);
    nbNoeud = firstNoeud->getNbrFils();
    lastNoeud = firstNoeud;
    srand ( time(NULL) );
    mode = 2;
    // la liste chainee pour nous aider a choisir un noeud
    fichierlogthread = NULL;

    tableScore.resize(1000);
    tableMoyeneScore.resize(10);
    tableMoyeneMin.resize(10);
    tableMoyeneMax.resize(10);
    nbMeilleurScore = 0;

    cout<<"arbre construit!"<<endl;
}


// ACCESSEURS
noeudUCT * arbreUCT::getNoeudRacine() {
    return firstNoeud;
}

void arbreUCT::setNoeudRacine(noeudUCT * newRacine) {
    firstNoeud=newRacine;
}

vector<vector<vecteurRave> > * arbreUCT::getlisteChainee() {
    return listeChainee;
}

vector<vector<vecteurRave> > * arbreUCT::getlisteCustom() {
    return listeCustom;
}


void arbreUCT::setlisteChainee(vector<vector<vecteurRave> > *  maliste) {
    listeChainee=maliste;
}
void arbreUCT::setlisteCustom(vector<vector<vecteurRave> > * maliste) {
    listeCustom=maliste;
}



// METHODE
//retourne le ratio nombre de passages tentes / nombre de victoires
/*
mpq_class * arbreUCT::getRatio() {
    //  return( (double) nbrVictoires / nbrPassages ) ;
    return nbrPiecesPosees;

}
*/


// retourne le coup qu'il va falloir jouer (le systeme determinera qui doit jouer)
Coup arbreUCT::trouverProchainCoup(int nbRepet) {
    for (int i =0; i<nbRepet; i++) {
        dessente();
    }
    return meilleurFils();
}

void arbreUCT::traceRave() {
    /*
    pthread_mutex_lock(&(*Mutex)[0]);
    maillonUCT * mTemp = listeCustom->getRacine();

    int i =0;
    //trace2::fichierlogListeFils<<"affichage du vecteur : "<<endl;

    while (mTemp !=NULL) {
    i++;
    //  trace2::fichierlogListeFils<<i<<" : "<<(int)mTemp->coup.x<<" - "<<(int)mTemp->coup.y<<" : "<<mTemp->nbrPiecesPosees<<" / "<<mTemp->nbJeux<<endl;
    mTemp = mTemp->suivant;
    }
    pthread_mutex_unlock(&(*Mutex)[0]);
    //trace2::fichierlogListeFils<<"Et blancs"<<endl;

    //MUTEX
    pthread_mutex_lock(&(*Mutex)[1]);
    mTemp = listeCustomBlanc->getRacine();

    i =0;

    while (mTemp !=NULL) {
    i++;
    //       trace2::fichierlogListeFils<<i<<" : "<<(int)mTemp->coup.x<<" - "<<(int)mTemp->coup.y<<" : "<<mTemp->nbrPiecesPosees<<" / "<<mTemp->nbJeux<<endl;
    mTemp = mTemp->suivant;
    }
    pthread_mutex_unlock(&(*Mutex)[1]);
    */
}


bool arbreUCT::dessente2() {
    //trickRave();
    cout<<"dessente"<<endl;
    for (int i = 0; i< NBDESCENTES; i ++) {
        dessente();
    }
}


bool arbreUCT::dessente2(int nbd) {
    cout<<"dessente nbd"<<endl;
    for (int i = 0; i< nbd; i ++) {
        if( nbrPassages % 500==0){

            cout<<"deja "<<i<<"( "<<nbrPassages<<") descentes"<<endl;
        }
       // cout<<"on va faire une descente."<<endl;
        dessente();
        if(i==10){
            cout<<"pause ici..."<<endl;
            int pause;
          //  cin>>pause;
            cout<<"go"<<endl;
        }
        // cout<<"on vient de faire une descente."<<endl;
    }

}


bool arbreUCT::dessente() { //fait une dessente, puis une remontée, renvoie true si ordi gagne, false sinon.
    //cout<<"dessente : debut"<<endl;
    if (fichierlogthread == NULL) {
      /*  char * t = (char *)pthread_self();
        char t2 [14]; //= (char *) malloc(sizeof(char)*14);
        for (int i = 0; i< 10; i++) {
            t2[i]= abs(t[i] %26 ) + 65;
        }


        t2[10] = '.';
        t2[11] = 't';
        t2[12] = 'x';
        t2[13] = 't';
        */
        fichierlogthread = new ofstream("GPtrace.txt", std::ios::out );
        fichierlogthread2 = new ofstream("GPtraceM.txt", std::ios::out );
    }
    *pActuel = *pInit;
    //pActuel = new EPlateau(pInit->getFichier());
    //pActuel = new EPlateau(pInit);
    // pInit;
    lastNoeud = firstNoeud;
    etage = 0;
    vector<noeudUCT *> listeNoeuds;
    ////cout.seekp(0,ios::beg); // miserable trick :D
    listeNoeuds.push_back(lastNoeud);
    cptTemp=0;
    int cpttrace = 0;
    //cout<<"on va noeudsuivanter"<<endl;

    double embranchementTotal = 1;
    double embranchementTotal2 = 1;
       // cout<<firstNoeud->getProba()<<endl;
    while (noeudSuivant()) {
/*
        cout<<endl<<
        "+++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl<<endl<<
        "            profondeur  :  "<<cpttrace<<endl<<endl<<
        "            "<<lastNoeud->getCoup()<<endl<<endl<<
        "+++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl<<endl;
        pActuel->affichePlateau();
        //int pause;
        //cin>>pause;
*/
        listeNoeuds.push_back(lastNoeud);
        cpttrace++;
        embranchementTotal =  lastNoeud->getProba() * embranchementTotal;
		//cout<<">>>>>>>>>>>>>>><EMBRANCHEMENT TOTAL: "<<lastNoeud->getProba()<<" - "<<embranchementTotal<<endl;

        //cout<<cpttrace<<endl;
    }
    //cout<<"TAILLE LISTE NOEUDS : "<<listeNoeuds.size()<<endl;
    //cout<<"on maj les données obtenues."<<endl;
    pthread_mutex_unlock(&(*tableMutex)[cptTemp]);//libération du dernier mutex locked
    nbrPassages++;
   // cout<<"..."<<endl;
    //cout<<"REMONTEE====> scoring: "<<lastNoeud->getScore()<<endl;;
     // listeNoeuds[0]->passage(lastNoeud->getScore(), embranchementTotal2 );
     // listeNoeuds[0]->passage(lastNoeud->getScore(), embranchementTotal2 );
	embranchementTotal2 = embranchementTotal;

    double oldProba ;

    int score = lastNoeud->getScore();

    for (int i=1; i<listeNoeuds.size()-1 ; i++) {
        //cout<<" i : "<<i<<" ( < à "<<listeNoeuds.size()-1 <<")"<<endl;
        //cout<<"embranchementTotal2: "<<embranchementTotal2<<endl;
        if(embranchementTotal2<1){

            //        int nbPi =  listeNoeuds[i]->getNbrPiecesPosees();
            //        int nbPass =  listeNoeuds[i]->getNombreDePassages();
            oldProba = listeNoeuds[i]->getProba();
            //cout<<"nbPi: "<<nbPi<<" nbPass: "<<nbPass<<" score: "<<lastNoeud->getScore()<<endl;
            //cout<<" coup : "<<listeNoeuds[i]->getCoup()<<endl;
            //mise à jour du vecteur RAVE
            (*listeCustom)[listeNoeuds[i]->getCoup().place.x][listeNoeuds[i]->getCoup().place.y].majValeurs(score, pActuel->poToInt(coupToPo(listeNoeuds[i]->getCoup()) ), listeNoeuds[i]->getProba() , embranchementTotal );
            //    listeNoeuds[i]->setNbrPiecesPosees((nbPi*nbPass+lastNoeud->getScore())/(nbPi+1));
            // listeNoeuds[i]->setNbrPiecesPosees(nbPi+lastNoeud->getScore()); //score = somme brutale des pieces posées
            // listeNoeuds[i]->setNombreDePassages(nbPass+1); //score = somme brutale des pieces posées
            listeNoeuds[i]->passage(score, embranchementTotal2);

           // cout<<"trace !!! ET2  pb, ET2/pb : "<<embranchementTotal2<<" / "<<listeNoeuds[i]->getProba() <<" =  "<<embranchementTotal2/listeNoeuds[i]->getProba() <<endl;

            embranchementTotal2 = embranchementTotal2/oldProba ;

        } else {
            listeNoeuds[i]->setScore(score);
        }
    }

/*
        for (int k=0; k<listeCustom->size(); k++) {
            for (int l=0; l<(*listeCustom)[k].size();l++) {
                (*listeCustom)[k][l].partieFinie(lastNoeud->getScore());
            }
        }
        if (!pthread_mutex_trylock(&(*Mutex)[0])) {

            for (int k=0; k<listeCustom->size(); k++) {
                for (int l=0; l<(*listeCustom)[k].size();l++) {
                    (*listeCustom)[k][l].partieFinie(&(*listeChainee)[k][l]) ;
                }
            }

            delete listeCustom;

            for (int k=0; k<listeCustom->size(); k++) {
                for (int l=0; l<(*listeCustom)[k].size();l++) {
                    (*listeCustom)[k][l] = new vecteurRave((*listeChainee)[k][l]);
                }
            }

            pthread_mutex_unlock(&(*Mutex)[0]);
        }
        */
    //    cout<<"p fin descente : "<<endl;
  //      pActuel->affichePlateau();
//        cout<<"hop"<<endl;
        //cout<<pActuel<<endl;
        //delete pActuel;
        //cout<<"hop 2"<<endl;
        //pActuel = pInit;
        tableScore[nbrPassages % 500] = pActuel->getScore();


        if( nbrPassages % 500==0){
            cout<<"passages : "<<nbrPassages<<endl;
            double moy = 0;
            int min = pActuel->getTaille()*pActuel->getTaille();
            int max = 0;
            for(int i =0; i < 500; i++){
                moy += tableScore[i];
                if (tableScore[i]<min)
                    min = tableScore[i];
                if (tableScore[i]>max)
                    max = tableScore[i];
            }
            moy /= 500;
            //(*fichierlogthread)<<nbrPassages<<" "<<moy<<" "<<min<<" "<<max<<endl;

            //if(nbrPassages /500 % 10!=0 ){
                tableMoyeneScore[nbrPassages /500 % 10] = moy;
                tableMoyeneMin[nbrPassages /500 % 10] = min;
                tableMoyeneMax[nbrPassages /500 % 10] = max;
            //} else {
            if(nbrPassages /500 % 10==0 ){
                double moy2 = 0;
                double min2 = 0;
                double max2 = 0;
                for(int i =0; i < 10; i++){
                    moy2 += tableMoyeneScore[i];
                    min2 += tableMoyeneMin[i];
                    max2 += tableMoyeneMax[i];
                }
                (*fichierlogthread2)<<nbrPassages<<" "<<moy2/10<<" "<<min2/10<<" "<<max2/10<<endl;
            }


            cout<<"moyene : "<<moy<<"min : "<<min<<" max : "<<max<<endl;
            cout<<"meilleur score : "<<pInit->getMeilleurScore()<<" atteint "<< nbMeilleurScore <<" fois "<<endl;

            pActuel->affichePlateau();
            (*fichierlogthread)<<nbrPassages<<" "<<moy<<" "<<min<<" "<<max<<endl;

        }

    //}
       // delete pActuel;

        if(pActuel->getScore()>= pInit->getMeilleurScore()){
            if(pActuel->getScore()== pInit->getMeilleurScore()){
                nbMeilleurScore++;
            } else {
                nbMeilleurScore=1;
            }
            cout<<"score : "<<pActuel->getScore()<<" > "<<pInit->getMeilleurScore()<<endl;
            pInit->setScore(pActuel->getScore());
            pActuel->affichePlateau();

        }
        listeNoeuds.resize(0);
        //cout<<"fin de la "<<nbrPassages<<"° descente..."<<endl;
        //int pause;
        //cin>>pause;
       // cout<<"________________________________________________________________"<<endl;
        //(*fichierlogthread)<<"dessente fin"<<endl;
        //    delete lastNoeud;

}





bool trace(int n) {
    // //cout<<"trace"<<n<<endl;
    return 0;
}

bool arbreUCT::noeudSuivant() { //choisit le noeud sur lequel on dessend, et y dessendre. (MAJ de Goban ect...)

   // cout<<"on est ici pour choisir le noeud suivant."<<endl;

    etage++;
    Coup meilleurCoup; //le coup supposé meilleur.

    noeudUCT * nTemp = NULL; // = new noeudUCT();
    Coup cTemp; //coup temporaire (change à chauqe boucle)
    noeudUCT * nMem = NULL; //meilleur coup croisé.
    double vMem = 0; //valeur du meilleur coup croisé.
    double vTemp = 0;
    Coord caseContrainte = pActuel->caseLaPlusContrainte();
    //cout<<(int)caseContrainte.x<<" - "<<(int)caseContrainte.y<<endl;
    if(caseContrainte.x<0){
       // cout<<"on est arrivé au bout d'une descente..."<<endl;
        nMem= NULL;
    } else {
    //si on a au moins deux cases déja explorées
        if (lastNoeud->getNbrFils()>0) {
         //   cout<<"On a quelques fils"<<endl;
       //     cout<<(int)caseContrainte.x<<" - "<<(int)caseContrainte.y<<endl;

    //pActuel->getPlateau[caseContrainte.x][caseContrainte.y]
            //vector<vector<vecteurRave> > * listeChainee;


            vector<Po> superVecteur = pActuel->vecteurCase(caseContrainte);
            vector<pieceNotee> megaVecteur;
            megaVecteur.resize(pActuel->getTaille()*pActuel->getTaille()*4);

           // cout<<"juste avant le for"<<endl;

            for (int k = 0; k<megaVecteur.size(); k++) {
                megaVecteur[k].piece=superVecteur[k];
                megaVecteur[k].note = 1;
                if(superVecteur[k].p.estPose==false){
                    megaVecteur[k].note = -1;
                }
                else {
                   // cout<<"piece jouable : "<<megaVecteur[k].piece.p.numero<<endl;
                }
            }
            noeudUCT * noeudTemp=lastNoeud->getFils();

            //cout<<"juste avant le while"<<endl;

            while (noeudTemp != NULL) {
                short num = pActuel->poToInt( coupToPo(noeudTemp->getCoup()) );
                //Po pieceO = intToPo(num);
                //cout<<"valeur choix : "<<noeudTemp->getCoup()<<" : "  <<noeudTemp->valeurChoix(pActuel->getTaille())<<endl;
                megaVecteur[num].note +=  noeudTemp->valeurChoix(pActuel->getTaille(), etage, lastNoeud->getNombreDePassages() );
              //  cout<< megaVecteur[num].piece.p.numero<<" : "<<megaVecteur[num].note<<endl;
                /*if(etage==10){
                        cout<< megaVecteur[num].piece.p.numero<<" -> "<<*noeudTemp<<endl;
                } */
                noeudTemp=noeudTemp->getFrereG();
            }

    //Rave
    //le vecteur RAVE est trié
           double ratioMax = 0;
            int posMax=-1;
            for (int i=0; i<megaVecteur.size(); i++) {
                if(megaVecteur[i].note > 0){
                    if(megaVecteur[i].note == 1){
                       megaVecteur[i].note+=20;
                    }
                    megaVecteur[i].note +=  5* (*listeCustom)[caseContrainte.x][caseContrainte.y].getRatio(i) ; // / (pActuel->getTaille()*pActuel->getTaille());
                   /* if(etage==1){
                        cout<<megaVecteur[i].note <<endl;
                    } */
                }
                //recherche du ratio max
                if (megaVecteur[i].note > ratioMax) {
                    ratioMax = megaVecteur[i].note;
                    posMax=i;
                }
            }
            if(posMax==-1){
                meilleurCoup.p.numero = 0;
                //nMem = NULL;
            } else {
                meilleurCoup.orientation = megaVecteur[posMax].piece.orient;
                meilleurCoup.p = megaVecteur[posMax].piece.p;
                meilleurCoup.place = caseContrainte;
            }

            //cout<<"fin du if"<<endl;

        } else {//prendre le meilleur qu n'est pas encore posé
            //cout<<"On a pas de fils"<<endl;
            //cout<<(int)caseContrainte.x<<" - "<<(int)caseContrainte.y<<endl;

            Po best = (*listeCustom)[(int)caseContrainte.x][(int)caseContrainte.y].trouverMeilleurMaillon(pActuel);
            meilleurCoup.orientation = best.orient;
            meilleurCoup.p = best.p;
            meilleurCoup.place = caseContrainte;
        }
        //cout<<meilleurCoup<<" : "<<meilleurCoup.p.numero<<endl;
        //      int pause; cin>>pause;
        if(meilleurCoup.p.numero !=0){
            //cout<<"Ok ! ;-) "<<endl;
            nMem = lastNoeud->creerFils(meilleurCoup, pActuel->getNbPiecesPossibles(caseContrainte));
            //cout<<"nMem : "<<nMem<<" : "<<nMem->getNbrFils()<<endl;
        } else {
            nMem= NULL;
        }
    }

//Y dessendre :

    if (nMem != NULL) {
        //cout<<"on va descendre en "<<meilleurCoup<<" ( "<<nMem->getCoup()<<" ) "<<endl;
        bool bTemp = pActuel->jouer(meilleurCoup);
        if(!bTemp ){
            pInit->affichePlateau();
            pActuel->affichePlateau();
            cout<<"on va reprendre..."<<endl;
            int pause;
            cin>>pause;
        }
        // Mise a jour de la listeChainee
        if (nMem->getNombreDePassages() == 0) {
            //         nMem->creerToutLesFils(gobanActuel);
            nbNoeud +=nMem->getNbrFils();
        }

       // cout<<" nb fils : "<<lastNoeud->getNbrFils()<<endl;
        lastNoeud = nMem;
        //cout<<" nb fils du fils : "<<lastNoeud->getNbrFils()<<endl;
        return true;

    } else { //alors, le noeud est une fin de partie.
        if( nbrPassages % 500==0){

            cout<<"A la fin : score : "<<pActuel->getScore()<<endl;
        }
        lastNoeud->setScore(pActuel->getScore());
        return false;
    }
}

//permet de choisir le meilleur fils apres les descentes
Coup arbreUCT::meilleurFils() {


    noeudUCT * nTemp = firstNoeud->getFils() ;
    Coup cSav = nTemp->getCoup();
    double rSav = (nTemp->getRatio())
    +(*listeChainee)[cSav.place.x][cSav.place.y].getRatio(pActuel->poToInt(coupToPo(nTemp->getCoup()))) * 2; // ratio
    double vTemp;
    while (nTemp != NULL) {

        if (rSav < nTemp->getRatio() + (*listeChainee)[cSav.place.x][cSav.place.y].getRatio(pActuel->poToInt(coupToPo(nTemp->getCoup())))* 2) {
            rSav = nTemp->getRatio() + (*listeChainee)[cSav.place.x][cSav.place.y].getRatio(pActuel->poToInt(coupToPo(nTemp->getCoup())))* 2;

            cSav = nTemp->getCoup();
        }
        nTemp = nTemp->getFrereG();
    }
   /* if (rSav<1.5) { //redessendre à 1.25?
        cSav.x=-101;
        cSav.y=-101;
        cSav.c=NOIR;
    }
    */
    return cSav;

}


bool arbreUCT::allerA(Coup c) {
    //cout<<c.x<<" - "<<c.y<<endl;
    cout<<"allerA : "<<firstNoeud<<endl;
    //firstNoeud = firstNoeud->getFils(c);
    if (firstNoeud== NULL) {
        cout<<"probleme"   <<endl;
    } else {
        cout<<"ok"<<endl;
    }
    noeudUCT * nTemp = firstNoeud->getFils();
    noeudUCT * nTemp2;
    firstNoeud= NULL;
    while (nTemp != NULL) {
        if (nTemp->getCoup() == c ) {
            firstNoeud = nTemp;
            nTemp = nTemp->getFrereG();
        } else {
            nTemp2 = nTemp->getFrereG();
            delete nTemp;
            nTemp = nTemp2;
        }
    }
    cout<<firstNoeud<<endl;
    if (firstNoeud ==NULL) {
        firstNoeud = new noeudUCT();
    }

   // delete pActuel;
    *pActuel = *pInit;
    cout<<"if"<<endl;
    if (firstNoeud->getNbrFils()==0) {
        cout<<"creer tt les fils!"<<endl;
//        firstNoeud->creerToutLesFils(pActuel);
        cout<<"change last noeud!"<<endl;
        lastNoeud = firstNoeud->getFils();
        cout<<"next"<<endl;
        while (lastNoeud != NULL) {
            //        cout<<lastNoeud->getCoup().x<<" - "<<lastNoeud->getCoup().y<<endl;
            lastNoeud = lastNoeud->getFrereG();
        }
    }
    lastNoeud = firstNoeud;
    cout<<"fin AllerA"<<endl;
}


void arbreUCT::traceFils(int nb) {
    /*
    //  trace2::fichierlogListeFils<<"RATIO A CE TEMPS : "<<nbrPierresPosees<<" / "<<nbrPassages<< (double) nbrPierresPosees/nbrPassages<<endl;
    noeudUCT * frereTemp = firstNoeud->getFils();
    //trace2::fichierlogListeFils.seekp(0,ios::beg);
    //    trace2::fichierlogListeFils<<"nombre total de noeuds dans l'arbre : "<<nbNoeud<<endl;
    //    trace2::fichierlogListeFils<<"Liste de fils : "<<endl;
    int nbVicIci = 0;
    int nbPassagesIci = 0 ;
    double vMem = 0;
    Coup cMem;
    while (frereTemp !=NULL) {
        nbVicIci += frereTemp->getNbrPiecesPosees();
        nbPassagesIci +=frereTemp->getNombreDePassages();
        if (frereTemp->getNombreDePassages()>0)

            //          trace2::fichierlogListeFils<<" - "<<frereTemp->getCoup().c<<" : "<< (int)frereTemp->getCoup().x <<" - "<<(int)frereTemp->getCoup().y <<" : "<<frereTemp->getNbrVictoires()<<" / "<<frereTemp->getNombreDePassages()<<" : "<<frereTemp->getRatio()<<" + "<<listeCustomNoir->trouverRatio(frereTemp->getCoup()) * 3<<" = "<<frereTemp->getRatio() + listeCustomNoir->trouverRatio(frereTemp->getCoup())* 3<<endl;
            if ((frereTemp->getRatio() + listeCustomNoir->trouverRatio(frereTemp->getCoup())*3 ) > vMem) {
                vMem = frereTemp->getRatio() + listeCustomNoir->trouverRatio(frereTemp->getCoup())* 3;

                cMem = frereTemp->getCoup();
                trace2::fichierlogListeFils<<"change : "<<vMem<<endl;
            }
        frereTemp = frereTemp->getFrereG();
    }
    trace2::fichierlogListeFils<<"BEST (new formule) : "<<(int)cMem.x<<" - "<<(int)cMem.y<<" : "<<vMem<<endl;
        */
}

void arbreUCT::majtable(vector<vector <double> > * table) {
    /*
    noeudUCT * nTemp = firstNoeud->getFils() ;
    //cout<<nTemp<<endl;
    cout<<"Arbre UCT : maj table : "<<endl;
    while (nTemp != NULL) {
        (*table)[nTemp->getCoup().place.x][nTemp->getCoup().place.y] = (nTemp->getRatio() +  listeChaineeNoir->trouverRatio(nTemp->getCoup())* 2);
        cout<<(*table)[nTemp->getCoup().place.x][nTemp->getCoup().place.y]<<endl;
        nTemp = nTemp->getFrereG();
    }
    cout<<"fin maj table"<<endl;
    */
}


